package abs.service;

import abs.dao.CompaniasDAO;
import abs.dao.GrupoProveedoresDAO;
import abs.dao.ProveedoresDAO;
import abs.dao.TipoProveedoresDAO;

import abs.domain.Companias;
import abs.domain.GrupoProveedores;
import abs.domain.Proveedores;
import abs.domain.TipoProveedores;

import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

/**
 * Spring service that handles CRUD requests for Proveedores entities
 * 
 */

@Service("ProveedoresService")
@Transactional
public class ProveedoresServiceImpl implements ProveedoresService {

	/**
	 * DAO injected by Spring that manages Companias entities
	 * 
	 */
	@Autowired
	private CompaniasDAO companiasDAO;

	/**
	 * DAO injected by Spring that manages GrupoProveedores entities
	 * 
	 */
	@Autowired
	private GrupoProveedoresDAO grupoProveedoresDAO;

	/**
	 * DAO injected by Spring that manages Proveedores entities
	 * 
	 */
	@Autowired
	private ProveedoresDAO proveedoresDAO;

	/**
	 * DAO injected by Spring that manages TipoProveedores entities
	 * 
	 */
	@Autowired
	private TipoProveedoresDAO tipoProveedoresDAO;

	/**
	 * Instantiates a new ProveedoresServiceImpl.
	 *
	 */
	public ProveedoresServiceImpl() {
	}

	/**
	 * Load an existing Proveedores entity
	 * 
	 */
	@Transactional
	public Set<Proveedores> loadProveedoress() {
		return proveedoresDAO.findAllProveedoress();
	}

	/**
	 * Save an existing Proveedores entity
	 * 
	 */
	@Transactional
	public void saveProveedores(Proveedores proveedores) {
		Proveedores existingProveedores = proveedoresDAO.findProveedoresByPrimaryKey(proveedores.getPr100copr());

		if (existingProveedores != null) {
			if (existingProveedores != proveedores) {
				existingProveedores.setPr100copr(proveedores.getPr100copr());
				existingProveedores.setPr100ruc(proveedores.getPr100ruc());
				existingProveedores.setPr100nomb(proveedores.getPr100nomb());
				existingProveedores.setPr100ciud(proveedores.getPr100ciud());
				existingProveedores.setPr100dire(proveedores.getPr100dire());
				existingProveedores.setPr100telf(proveedores.getPr100telf());
				existingProveedores.setPr100emai(proveedores.getPr100emai());
				existingProveedores.setPr100rele(proveedores.getPr100rele());
				existingProveedores.setPr100cgre(proveedores.getPr100cgre());
				existingProveedores.setPr100auto(proveedores.getPr100auto());
				existingProveedores.setPr100cont(proveedores.getPr100cont());
				existingProveedores.setPr100tar(proveedores.getPr100tar());
				existingProveedores.setPr100obs(proveedores.getPr100obs());
				existingProveedores.setPr100obs2(proveedores.getPr100obs2());
				existingProveedores.setPr100plaz(proveedores.getPr100plaz());
				existingProveedores.setPr100ctadb(proveedores.getPr100ctadb());
				existingProveedores.setPr100ctacr(proveedores.getPr100ctacr());
				existingProveedores.setPr100load(proveedores.getPr100load());
				existingProveedores.setPr100fead(proveedores.getPr100fead());
				existingProveedores.setPr100lomo(proveedores.getPr100lomo());
				existingProveedores.setPr100femo(proveedores.getPr100femo());
			}
			proveedores = proveedoresDAO.store(existingProveedores);
		} else {
			proveedores = proveedoresDAO.store(proveedores);
		}
		proveedoresDAO.flush();
	}

	/**
	 * Delete an existing Companias entity
	 * 
	 */
	@Transactional
	public Proveedores deleteProveedoresCompanias(Integer proveedores_pr100copr, String related_companias_co000nocia) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(proveedores_pr100copr, -1, -1);
		Companias related_companias = companiasDAO.findCompaniasByPrimaryKey(related_companias_co000nocia, -1, -1);

		proveedores.setCompanias(null);
		related_companias.getProveedoreses().remove(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_companias = companiasDAO.store(related_companias);
		companiasDAO.flush();

		companiasDAO.remove(related_companias);
		companiasDAO.flush();

		return proveedores;
	}

	/**
	 * Return all Proveedores entity
	 * 
	 */
	@Transactional
	public List<Proveedores> findAllProveedoress(Integer startResult, Integer maxRows) {
		return new java.util.ArrayList<Proveedores>(proveedoresDAO.findAllProveedoress(startResult, maxRows));
	}

	/**
	 */
	@Transactional
	public Proveedores findProveedoresByPrimaryKey(Integer pr100copr) {
		return proveedoresDAO.findProveedoresByPrimaryKey(pr100copr);
	}

	/**
	 * Delete an existing GrupoProveedores entity
	 * 
	 */
	@Transactional
	public Proveedores deleteProveedoresGrupoProveedores(Integer proveedores_pr100copr, String related_grupoproveedores_grppr100cdgo) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(proveedores_pr100copr, -1, -1);
		GrupoProveedores related_grupoproveedores = grupoProveedoresDAO.findGrupoProveedoresByPrimaryKey(related_grupoproveedores_grppr100cdgo, -1, -1);

		proveedores.setGrupoProveedores(null);
		related_grupoproveedores.getProveedoreses().remove(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_grupoproveedores = grupoProveedoresDAO.store(related_grupoproveedores);
		grupoProveedoresDAO.flush();

		grupoProveedoresDAO.remove(related_grupoproveedores);
		grupoProveedoresDAO.flush();

		return proveedores;
	}

	/**
	 * Save an existing TipoProveedores entity
	 * 
	 */
	@Transactional
	public Proveedores saveProveedoresTipoProveedores(Integer pr100copr, TipoProveedores related_tipoproveedores) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(pr100copr, -1, -1);
		TipoProveedores existingtipoProveedores = tipoProveedoresDAO.findTipoProveedoresByPrimaryKey(related_tipoproveedores.getTipopr100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existingtipoProveedores != null) {
			existingtipoProveedores.setTipopr100cdgo(related_tipoproveedores.getTipopr100cdgo());
			existingtipoProveedores.setTipopr100desc(related_tipoproveedores.getTipopr100desc());
			existingtipoProveedores.setTipopr100esta(related_tipoproveedores.getTipopr100esta());
			existingtipoProveedores.setTipopr100load(related_tipoproveedores.getTipopr100load());
			existingtipoProveedores.setTipopr100fead(related_tipoproveedores.getTipopr100fead());
			existingtipoProveedores.setTipopr100lomo(related_tipoproveedores.getTipopr100lomo());
			existingtipoProveedores.setTipopr100femo(related_tipoproveedores.getTipopr100femo());
			related_tipoproveedores = existingtipoProveedores;
		} else {
			related_tipoproveedores = tipoProveedoresDAO.store(related_tipoproveedores);
			tipoProveedoresDAO.flush();
		}

		proveedores.setTipoProveedores(related_tipoproveedores);
		related_tipoproveedores.getProveedoreses().add(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_tipoproveedores = tipoProveedoresDAO.store(related_tipoproveedores);
		tipoProveedoresDAO.flush();

		return proveedores;
	}

	/**
	 * Save an existing Companias entity
	 * 
	 */
	@Transactional
	public Proveedores saveProveedoresCompanias(Integer pr100copr, Companias related_companias) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(pr100copr, -1, -1);
		Companias existingcompanias = companiasDAO.findCompaniasByPrimaryKey(related_companias.getCo000nocia());

		// copy into the existing record to preserve existing relationships
		if (existingcompanias != null) {
			existingcompanias.setCo000nocia(related_companias.getCo000nocia());
			existingcompanias.setCo000logo(related_companias.getCo000logo());
			existingcompanias.setCo000nomb(related_companias.getCo000nomb());
			existingcompanias.setCo000nosu(related_companias.getCo000nosu());
			existingcompanias.setCo000dire(related_companias.getCo000dire());
			existingcompanias.setCo000repr(related_companias.getCo000repr());
			existingcompanias.setCo000cont(related_companias.getCo000cont());
			existingcompanias.setCo000nreg(related_companias.getCo000nreg());
			existingcompanias.setCo000clca(related_companias.getCo000clca());
			existingcompanias.setCo000mofu(related_companias.getCo000mofu());
			existingcompanias.setCo000notr(related_companias.getCo000notr());
			existingcompanias.setCo000idtr(related_companias.getCo000idtr());
			existingcompanias.setCo000meci(related_companias.getCo000meci());
			existingcompanias.setCo000mepr(related_companias.getCo000mepr());
			existingcompanias.setCo000incc(related_companias.getCo000incc());
			existingcompanias.setCo000inut(related_companias.getCo000inut());
			existingcompanias.setCo000incp(related_companias.getCo000incp());
			existingcompanias.setCo000incf(related_companias.getCo000incf());
			existingcompanias.setCo000baca(related_companias.getCo000baca());
			existingcompanias.setCo000fir1(related_companias.getCo000fir1());
			existingcompanias.setCo000fir2(related_companias.getCo000fir2());
			existingcompanias.setCo000esta(related_companias.getCo000esta());
			existingcompanias.setCo000load(related_companias.getCo000load());
			existingcompanias.setCo000fead(related_companias.getCo000fead());
			existingcompanias.setCo000lomo(related_companias.getCo000lomo());
			existingcompanias.setCo000femo(related_companias.getCo000femo());
			related_companias = existingcompanias;
		}

		proveedores.setCompanias(related_companias);
		related_companias.getProveedoreses().add(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_companias = companiasDAO.store(related_companias);
		companiasDAO.flush();

		return proveedores;
	}

	/**
	 * Delete an existing TipoProveedores entity
	 * 
	 */
	@Transactional
	public Proveedores deleteProveedoresTipoProveedores(Integer proveedores_pr100copr, String related_tipoproveedores_tipopr100cdgo) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(proveedores_pr100copr, -1, -1);
		TipoProveedores related_tipoproveedores = tipoProveedoresDAO.findTipoProveedoresByPrimaryKey(related_tipoproveedores_tipopr100cdgo, -1, -1);

		proveedores.setTipoProveedores(null);
		related_tipoproveedores.getProveedoreses().remove(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_tipoproveedores = tipoProveedoresDAO.store(related_tipoproveedores);
		tipoProveedoresDAO.flush();

		tipoProveedoresDAO.remove(related_tipoproveedores);
		tipoProveedoresDAO.flush();

		return proveedores;
	}

	/**
	 * Save an existing GrupoProveedores entity
	 * 
	 */
	@Transactional
	public Proveedores saveProveedoresGrupoProveedores(Integer pr100copr, GrupoProveedores related_grupoproveedores) {
		Proveedores proveedores = proveedoresDAO.findProveedoresByPrimaryKey(pr100copr, -1, -1);
		GrupoProveedores existinggrupoProveedores = grupoProveedoresDAO.findGrupoProveedoresByPrimaryKey(related_grupoproveedores.getGrppr100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existinggrupoProveedores != null) {
			existinggrupoProveedores.setGrppr100cdgo(related_grupoproveedores.getGrppr100cdgo());
			existinggrupoProveedores.setGrppr100name(related_grupoproveedores.getGrppr100name());
			existinggrupoProveedores.setGrppr100tipo(related_grupoproveedores.getGrppr100tipo());
			existinggrupoProveedores.setGrppr100clas(related_grupoproveedores.getGrppr100clas());
			existinggrupoProveedores.setGrppr100esta(related_grupoproveedores.getGrppr100esta());
			existinggrupoProveedores.setGrppr100load(related_grupoproveedores.getGrppr100load());
			existinggrupoProveedores.setGrppr100fead(related_grupoproveedores.getGrppr100fead());
			existinggrupoProveedores.setGrppr100lomo(related_grupoproveedores.getGrppr100lomo());
			existinggrupoProveedores.setGrppr100femo(related_grupoproveedores.getGrppr100femo());
			related_grupoproveedores = existinggrupoProveedores;
		} else {
			related_grupoproveedores = grupoProveedoresDAO.store(related_grupoproveedores);
			grupoProveedoresDAO.flush();
		}

		proveedores.setGrupoProveedores(related_grupoproveedores);
		related_grupoproveedores.getProveedoreses().add(proveedores);
		proveedores = proveedoresDAO.store(proveedores);
		proveedoresDAO.flush();

		related_grupoproveedores = grupoProveedoresDAO.store(related_grupoproveedores);
		grupoProveedoresDAO.flush();

		return proveedores;
	}

	/**
	 * Delete an existing Proveedores entity
	 * 
	 */
	@Transactional
	public void deleteProveedores(Proveedores proveedores) {
		proveedoresDAO.remove(proveedores);
		proveedoresDAO.flush();
	}

	/**
	 * Return a count of all Proveedores entity
	 * 
	 */
	@Transactional
	public Integer countProveedoress() {
		return ((Long) proveedoresDAO.createQuerySingleResult("select count(o) from Proveedores o").getSingleResult()).intValue();
	}
}
